package net.xiduth.io.io.File;

/*
 * Copyright 1998 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

/* @test
 @bug 4131169 4168988
 @summary Basic File constructor tests
 */

import java.io.File;
import java.util.ArrayList;

public class Cons {

	private static boolean debug = false;
	private static boolean old = false;
	private static boolean win32 = (File.separatorChar == '\\');

	private static String cvt(String s) {
		if (s == null)
			return s;
		if (win32)
			return s.replace('/', '\\');
		return s;
	}

	private static String[] slashPerms(String s) {
		if (!win32)
			return new String[] { s };
		if (s == null)
			return new String[] { s };
		int i = s.indexOf('/');
		if (i < 0)
			return new String[] { s };
		ArrayList a = new ArrayList();
		String p1 = s.substring(0, i);
		String[] p2 = slashPerms(s.substring(i + 1));
		for (int j = 0; j < p2.length; j++)
			a.add(p1 + '/' + p2[j]);
		for (int j = 0; j < p2.length; j++)
			a.add(p1 + '\\' + p2[j]);
		return (String[]) (a.toArray(new String[a.size()]));
	}

	static class F extends File {
		String exp;

		public F(String path) {
			super(path);
			this.exp = cons(path);
		}

		public F(String parent, String child) {
			super(parent, child);
			this.exp = cons(parent, child);
		}

		public F(F parent, String child) {
			super(parent, child);
			if (parent == null)
				this.exp = cons((String) null, child);
			else
				this.exp = cons(parent, child);
		}

	}

	private static String nos(String s) {
		if (s == null)
			return "null";
		else
			return "\"" + s + "\"";
	}

	private static void ok(String ans, String exp) {
		System.err.println(nos(ans) + " <== " + exp);
	}

	private static void err(String ans, String exp, String got)
			throws Exception {
		System.err.println(nos(ans) + " <-- " + exp + " ==> " + nos(got));
		if (!debug) {
			throw new Exception("Mismatch: " + exp + " ==> " + nos(got)
					+ ", should be " + nos(ans));
		}
	}

	private static void ck(String ans, String exp, String got) throws Exception {
		if ((got == ans) || ((got != null) && got.equals(ans)))
			ok(ans, exp);
		else
			err(ans, exp, got);
	}

	private static String cons(String arg) {
		return "new File(" + nos(arg) + ")";
	}

	private static String cons(String arg1, String arg2) {
		return "new File(" + nos(arg1) + ", " + nos(arg2) + ")";
	}

	private static String cons(F arg1, String arg2) {
		return "new File(" + arg1.exp + ", " + nos(arg2) + ")";
	}

	private static String op(String exp, String opname) {
		return exp + "." + opname + "()";
	}

	private static void ckpnp(F f, String parent, String name, String path)
			throws Exception {
		ck(cvt(path), op(f.exp, "getPath"), f.getPath());
		ck(cvt(parent), op(f.exp, "getParent"), f.getParent());
		ck(cvt(name), op(f.exp, "getName"), f.getName());
	}

	private static void ck1(String arg, String parent, String name, String path)
			throws Exception {
		String[] parg = slashPerms(arg);
		for (int i = 0; i < parg.length; i++)
			ckpnp(new F(parg[i]), parent, name, path);
	}

	private static void ck2(String arg1, String arg2, String parent,
			String name, String path) throws Exception {
		String[] parg1 = slashPerms(arg1);
		String[] parg2 = slashPerms(arg2);
		for (int i = 0; i < parg1.length; i++)
			for (int j = 0; j < parg2.length; j++)
				ckpnp(new F(parg1[i], parg2[j]), parent, name, path);
	}

	private static void ck2f(String arg1, String arg2, String parent,
			String name, String path) throws Exception {
		String[] parg1 = slashPerms(arg1);
		String[] parg2 = slashPerms(arg2);
		for (int i = 0; i < parg1.length; i++)
			for (int j = 0; j < parg2.length; j++) {
				F p = (parg1[i] == null) ? null : new F(parg1[i]);
				ckpnp(new F(p, parg2[j]), parent, name, path);
			}
	}

	static void testBoth() throws Exception {

		/* Null/empty constructor cases */
		ck1("", null, "", "");
		ck2(null, "", null, "", "");
		ck2("", "", null, "", "/"); /* ugh */
		ck2f("", "", null, "", "/");
		if (!old) {
			/* throws NullPointerException */
			ck2f(null, "", null, "", "");
		}

		/* Separators-in-pathnames cases */
		ck1("/", null, "", "/");
		ck2f("/", "", null, "", "/");

		/* One-arg constructor cases */
		ck1("foo", null, "foo", "foo");
		ck1("/foo", "/", "foo", "/foo");
		ck1("/foo/bar", "/foo", "bar", "/foo/bar");
		ck1("foo/bar", "foo", "bar", "foo/bar");
		if (!old) {
			ck1("foo/", null, "foo", "foo");
			ck1("/foo/", "/", "foo", "/foo");
			ck1("/foo//", "/", "foo", "/foo");
			ck1("/foo///", "/", "foo", "/foo");
			ck1("/foo//bar", "/foo", "bar", "/foo/bar");
			ck1("/foo/bar//", "/foo", "bar", "/foo/bar");
			ck1("foo//bar", "foo", "bar", "foo/bar");
			ck1("foo/bar/", "foo", "bar", "foo/bar");
			ck1("foo/bar//", "foo", "bar", "foo/bar");
		}

		/* Two-arg constructor cases, string parent */
		ck2("foo", "bar", "foo", "bar", "foo/bar");
		ck2("foo/", "bar", "foo", "bar", "foo/bar");
		ck2("/foo", "bar", "/foo", "bar", "/foo/bar");
		ck2("/foo/", "bar", "/foo", "bar", "/foo/bar");
		if (!old) {
			ck2("foo//", "bar", "foo", "bar", "foo/bar");
			ck2("foo", "bar/", "foo", "bar", "foo/bar");
			ck2("foo", "bar//", "foo", "bar", "foo/bar");
			ck2("/foo//", "bar", "/foo", "bar", "/foo/bar");
			ck2("/foo", "bar/", "/foo", "bar", "/foo/bar");
			ck2("/foo", "bar//", "/foo", "bar", "/foo/bar");
			ck2("foo", "/bar", "foo", "bar", "foo/bar");
			ck2("foo", "//bar", "foo", "bar", "foo/bar");
			ck2("/", "bar", "/", "bar", "/bar");
			ck2("/", "/bar", "/", "bar", "/bar");
		}

		/* Two-arg constructor cases, File parent */
		ck2f("foo", "bar", "foo", "bar", "foo/bar");
		ck2f("foo/", "bar", "foo", "bar", "foo/bar");
		ck2f("/foo", "bar", "/foo", "bar", "/foo/bar");
		ck2f("/foo/", "bar", "/foo", "bar", "/foo/bar");
		if (!old) {
			ck2f("foo//", "bar", "foo", "bar", "foo/bar");
			ck2f("foo", "bar/", "foo", "bar", "foo/bar");
			ck2f("foo", "bar//", "foo", "bar", "foo/bar");
			ck2f("/foo//", "bar", "/foo", "bar", "/foo/bar");
			ck2f("/foo", "bar/", "/foo", "bar", "/foo/bar");
			ck2f("/foo", "bar//", "/foo", "bar", "/foo/bar");
			ck2f("foo", "/bar", "foo", "bar", "foo/bar");
			ck2f("foo", "//bar", "foo", "bar", "foo/bar");
		}
	}

	static void testUnix() throws Exception {

		/* Separators-in-pathnames cases */
		if (!old) {
			ck1("//", null, "", "/");
		}

		/* One-arg constructor cases */
		if (!old) {
			ck1("//foo", "/", "foo", "/foo");
			ck1("///foo", "/", "foo", "/foo");
			ck1("//foo/bar", "/foo", "bar", "/foo/bar");
		}

		/* Two-arg constructors cases, string parent */
		if (!old) {
			ck2("//foo", "bar", "/foo", "bar", "/foo/bar");
		}

		/* Two-arg constructor cases, File parent */
		if (!old) {
			ck2f("//foo", "bar", "/foo", "bar", "/foo/bar");
		}

		File f = new File("/foo");
		if (!f.isAbsolute())
			throw new Exception(f + " should be absolute");

		f = new File("foo");
		if (f.isAbsolute())
			throw new Exception(f + " should not be absolute");
	}

	static void testWin32() throws Exception {

		if (!old) {
			/* Separators-in-pathnames cases */
			ck1("//", null, "", "//");

			/* One-arg constructor cases */
			ck1("//foo", "//", "foo", "//foo");
			ck1("///foo", "//", "foo", "//foo");
			ck1("//foo/bar", "//foo", "bar", "//foo/bar");

			ck1("z:", null, "", "z:");
			ck1("z:/", null, "", "z:/");
			ck1("z://", null, "", "z:/");
			ck1("z:/foo", "z:/", "foo", "z:/foo");
			ck1("z:/foo/", "z:/", "foo", "z:/foo");
			ck1("/z:/foo", "z:/", "foo", "z:/foo");
			ck1("//z:/foo", "z:/", "foo", "z:/foo");
			ck1("z:/foo/bar", "z:/foo", "bar", "z:/foo/bar");
			ck1("z:foo", "z:", "foo", "z:foo");

			/* Two-arg constructors cases, string parent */
			ck2("z:", "/", null, "", "z:/"); /* ## ? */
			ck2("z:", "/foo", "z:/", "foo", "z:/foo");
			ck2("z:/", "foo", "z:/", "foo", "z:/foo");
			ck2("z://", "foo", "z:/", "foo", "z:/foo");
			ck2("z:/", "/foo", "z:/", "foo", "z:/foo");
			ck2("z:/", "//foo", "z:/", "foo", "z:/foo");
			ck2("z:/", "foo/", "z:/", "foo", "z:/foo");
			ck2("//foo", "bar", "//foo", "bar", "//foo/bar");

			/* Two-arg constructor cases, File parent */
			ck2f("//foo", "bar", "//foo", "bar", "//foo/bar");

		}
	}

	public static void main(String[] args) throws Exception {
		old = new File("foo/").getPath().equals("foo/");
		if (old)
			System.err.println("** Testing old java.io.File class");
		testBoth();
		if (win32)
			testWin32();
		else
			testUnix();
	}

}
